package com.atguigu.feature.optional;

import org.junit.Test;

import java.util.Optional;
import java.util.stream.Stream;

/**
 * Created by Smexy on 2024/4/2
 */
public class Demo02TestOptional {

    @Test
    public void testCreateOptional() {
        // 1、创建被 Optional 封装的数据
        // String data = "aaa";
        String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        System.out.println("optional = " + optional);
    }

    @Test
    public void testOptionalGet() {
        // 1、创建被 Optional 封装的数据
        String data = "aaa";
        // String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、从 Optional 对象中获取封装的数据
        // 如果内部数据为 null，则抛出异常：java.util.NoSuchElementException: No value present
        String value = optional.get();
        System.out.println("value = " + value);
    }

    @Test
    public void testOptionalOrElse() {
        // 1、创建被 Optional 封装的数据
        // String data = "aaa";
        String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、从 Optional 对象中获取封装的数据
        // 如果内部封装的数据非空，则使用内部数据
        // 如果内部封装的数据为空，则使用备用数据（orElse()方法传入的参数）
        String value = optional.orElse("other value");
        System.out.println("value = " + value);
    }

    @Test
    public void testOptionalOrElseGet() {
        // 1、创建被 Optional 封装的数据
        String data = "aaa";
        // String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、从 Optional 对象中获取封装的数据
        // 如果内部封装的数据非空，则使用内部数据
        // 如果内部封装的数据为空，则使用供给型函数 Lambda 表达式中提供的数据
        String value = optional.orElseGet(() -> "在供给型函数式接口中生成数据");
        System.out.println("value = " + value);
    }

    @Test
    public void testOptionalOrElseThrow() {
        // 1、创建被 Optional 封装的数据
        // String data = "aaa";
        String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、从 Optional 对象中获取封装的数据
        // 如果内部封装的数据非空，则使用内部数据
        // 如果内部封装的数据为空，则抛出供给型函数提供的异常对象
        String value = optional.orElseThrow(()->new RuntimeException("原始数据为空"));
        System.out.println("value = " + value);
    }

    @Test
    public void testOptionalIsPresent() {
        // 1、创建被 Optional 封装的数据
        String data = "aaa";
        // String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、判断内部数据是否存在
        boolean present = optional.isPresent();
        System.out.println("present = " + present);
    }

    @Test
    public void testOptionalIfPresent() {
        // 1、创建被 Optional 封装的数据
        // String data = "aaa";
        String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、判断内部数据是否存在
        // 数据存在时，执行消费型接口内封装的操作
        optional.ifPresent(value -> {
            System.out.println("value = " + value);
        });
    }

    @Test
    public void testOptionalMap() {
        // 1、创建被 Optional 封装的数据
        // String data = "aaa";
        String data = null;

        // 2、封装 Optional 对象
        Optional<String> optional = Optional.ofNullable(data);

        // 3、对内部数据进行映射处理
        // 经过映射之后，会得到一个新的 Optional 对象
        // 内部数据存在时执行功能型函数式接口封装的操作，得到映射数据
        // 内部数据不存在时，返回一个空的 Optional
        Optional<String> newOptional = optional.map(value -> value.toUpperCase());

        // 4、从新 Optional 对象中获取数据
        String newValue = newOptional.orElse("other value");
        System.out.println("newValue = " + newValue);
    }
}
